home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 1 / Meeting Pearls Vol 1 (1994).iso / installed_progs / gfx / lise2.1 / mdl / src / mdllib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-31  |  54.8 KB  |  2,071 lines
  1. /*
  2.    Library routines to support Menu and Gadget primitives
  3.    in an easy (and hopefully Computer independent) way.
  4.    In stead of using the conventional STATIC structure initialization,
  5.    these routines support DYNAMIC structure initialization, which
  6.    is more flexible and easier to use.
  7.    All primitives (Push buttons, toggle buttons, scalers, selection boxes,
  8.    String boxes and Menustrips) are added to the new_window pointer
  9.    using the Function add_item.
  10.    Look at the file skeletton.c for examples on how to use this library
  11. */
  12.  
  13. #include <stdio.h>
  14. #include <math.h>
  15. #include <exec/types.h>
  16. #include <exec/ports.h>
  17. #include <exec/tasks.h>
  18. #include <exec/libraries.h>
  19. #include <exec/devices.h>
  20. #include <exec/memory.h>
  21. #include <exec/execbase.h>
  22. #include <exec/exec.h>
  23. #include <graphics/gfxbase.h>
  24. #include <graphics/gfx.h>
  25. #include <graphics/view.h>
  26. #include <graphics/rastport.h>
  27. #include <graphics/layers.h>
  28. #include <graphics/display.h>
  29. #include <graphics/gfxmacros.h>
  30. #include <intuition/intuition.h>
  31. #include <libraries/dos.h>
  32. #include <libraries/dosextens.h>
  33. #include <workbench/workbench.h>
  34. #include <workbench/startup.h>
  35. #include <workbench/icon.h>
  36.  
  37. #define  PUSH        1
  38. #define  TOGGLE      2
  39. #define  SCALEX      3
  40. #define  SCALEY      4
  41. #define  DIALOG      5
  42. #define  MENU        6
  43. #define  NEW_MENU    7
  44. #define  FILE_SELECT 8
  45. #define  BOARD       9
  46. #define  BULLETIN   10
  47. #define  SELECTION  11
  48. #define  MESSAGE    12
  49. #define  RADIO      13
  50. #define  ROWCOL     14
  51. #define  SCALEX11   15
  52. #define  SCALEY11   16
  53. #define  STRING     17
  54. #define  INTEGER    18
  55. #define  FLOAT      19
  56. #define  SCALEX00   20
  57. #define  SCALEY00   21
  58. #define  SELBOXGAD  201
  59. #define  FSELBOXGAD 202
  60. #define  FSELSTRING 203
  61. #define  SPECIALPRO 204
  62. #define  SPECIALPAR 205
  63. #define  SPECIALOK  206
  64. #define  SPECIALCAN 207
  65.  
  66. struct IntuitionBase *IntuitionBase = NULL;
  67. struct GfxBase *GfxBase;
  68. struct Library *AslBase;
  69. struct Screen *WBScreen = NULL;
  70. struct Window *my_window;
  71. struct Window *prop_window;
  72. struct Gadget *prop_gadget;
  73. struct NewWindow *my_new_window;
  74. struct Menu *menu_bar=NULL;
  75.  
  76. struct RastPort *rp;                  /* RastPort - Zeiger */
  77. struct IntuiMessage *message;         /* IntuiMessage - Zeiger */
  78. struct TmpRas tmp;
  79.  
  80. struct TextAttr topaz_font = {
  81.        /* STRPTR ta_Name */ "topaz.font",
  82.        /* UWORD ta_YSize */ 8,
  83.        /* UBYTE ta_style */ 0,
  84.        /* UBYTE ta_flags */ 0
  85.                              };
  86. struct FileRequester    {
  87.     APTR    rf_Reserved1;
  88.     BYTE    *rf_File;    /* Filename pointer        */
  89.     BYTE    *rf_Dir;    /* Directory name pointer    */
  90.     WORD    rf_Reserved2[5];
  91.     SHORT    rf_LeftEdge,rf_TopEdge;    /* Preferred window pos    */
  92.     SHORT    rf_Width,rf_Height;   /* Preferred window size    */
  93.     SHORT    rf_Reserved3;
  94.     LONG    rf_NumArgs;    /* A-la WB Args, for multiselects */
  95.     struct WBArg *rf_ArgList;
  96.     APTR    rf_UserData;    /* Applihandle (you may write!!) */
  97.     };
  98.  
  99. struct FileRequester *AllocFileRequest();
  100. void FreeFileRequest(struct FileRequester *ptr);
  101. char *RequestFile(struct FileRequester *ptr);
  102.  
  103. #ifdef MANX
  104. #pragma amicall(AslBase,30,AllocFileRequest())
  105. #pragma amicall(AslBase,36,FreeFileRequest(A0))
  106. #pragma amicall(AslBase,42,RequestFile(A0))
  107. #endif
  108.  
  109. #ifdef SAS
  110. #pragma libcall AslBase AllocFileRequest 1E 0
  111. #pragma libcall AslBase FreeFileRequest 24 801
  112. #pragma libcall AslBase RequestFile 2A 801
  113. #endif
  114.  
  115. USHORT *PointerMatrix;
  116.  
  117. int   propdwn = 0;
  118. int   last_gadgetid = 0;
  119. int    menu_line = 0;
  120. int    menu_column = 0;
  121. int    fn_number = 0;
  122. int    top_slider = -1;
  123. void   (*fn_command[160])();
  124. int    *var_value[160];
  125. int    var_funct[160];
  126. int    scale_var0[160];
  127. int    scale_var1[160];
  128. int    selector[160];
  129. int    acc_x=0;               /* accumulated x   */
  130. int    acc_y=0;               /* accumulated y   */
  131. int    bas_y=5;               /* base scale for y-increment */
  132. int    fin_flg=FALSE;         /* tells the MainLoop to termitate */
  133. char   menu_name[80];         /* store menu bar name */
  134. char   return_string[80];     /* string returned from dialog box */
  135. char   last_dir[80];
  136. char   last_file[80];
  137.  
  138. extern struct WBStartup *WBenchMsg;
  139. extern struct IconBase *IconBase;
  140.  
  141. struct memtree {
  142.    struct memtree *Next;
  143.    char *memory;
  144. } *mem_status = NULL;
  145.  
  146.  
  147. /* --------------------------------------------------------------
  148.    allocate memory for possible deallocation of a whole tree
  149.    -------------------------------------------------------------- */
  150. char *tree_alloc(amount)
  151. int amount;
  152. {
  153. struct memtree *memory;
  154.  
  155.    if(mem_status == NULL) 
  156.       mem_status = (struct memtree *) malloc(sizeof(struct memtree));
  157.    memory = (struct memtree *) malloc(amount + sizeof(struct memtree));
  158.    memory->Next = NULL;
  159.    mem_status->Next = memory;
  160.    return(&memory->memory);
  161. }
  162.  
  163. /* --------------------------------------------------------------
  164.    free a whole tree of memory allocated by tree_alloc
  165.    -------------------------------------------------------------- */
  166. void tree_free(start)
  167. struct memtree *start;
  168. {
  169. struct memtree *entry;
  170.  
  171.    mem_status = start;
  172.    entry = start;
  173.  
  174.    while(entry->Next != NULL) {
  175.       start = entry->Next;
  176.       free(entry);
  177.       entry = start;
  178.    }
  179. }
  180.  
  181. /* --------------------------------------------------------------
  182.    read directory information into buffer. directories are
  183.    preceeded by a /
  184.    -------------------------------------------------------------- */
  185. void read_dir(subdir,buffer)
  186. char subdir[];
  187. char *buffer[];
  188. {
  189. struct FileLock *actdir;
  190. struct FileInfoBlock *dirinfo;
  191. char s[80],z[80];
  192. int n,m,i,p;
  193.  
  194.    dirinfo = (struct FileInfoBlock *)AllocMem(sizeof(struct FileInfoBlock),0L);
  195.    actdir = (struct FileLock *) Lock(subdir,-2);
  196.  
  197.    if(actdir == 0) {
  198.       for(n=0;n<300;n++) {
  199.          if(buffer[n] != NULL) free(buffer[n]);
  200.          buffer[n] = NULL;
  201.       }
  202.       FreeMem(dirinfo,sizeof(struct FileInfoBlock));
  203.       return;
  204.    }
  205.  
  206.    n = Examine(actdir,dirinfo);
  207.    p = 0;
  208.    while(n != 0) {
  209.       n = ExNext(actdir,dirinfo);
  210.       if(n == 0) break;
  211.       m = 1; i = 0;
  212.       while(m != 0) {
  213.          m = dirinfo->fib_FileName[i];
  214.          s[i++] = m;
  215.       }
  216.       if(dirinfo->fib_DirEntryType > 0) {
  217.          strcpy(z,"/");
  218.       } else {
  219.          strcpy(z," ");
  220.       }
  221.       strcat(z,s);
  222.       if(buffer[p] == NULL) buffer[p] = (char *) malloc(32);
  223.       strcpy(buffer[p],z);
  224.       p = p + 1;
  225.    }
  226.    for(n=p;n<300;n++) {
  227.       if(buffer[n] != NULL) free(buffer[n]);
  228.       buffer[n] = NULL;
  229.    }
  230. /* ---------- Sorting buffer :--------- */
  231.    for(n = 1; n < (p - 1); n++) {
  232.       i = TRUE;
  233.       for(m = 0; m < (p - n); m++) {
  234.          if(strcmp(buffer[m],buffer[m+1]) > 0) {
  235.             strcpy(z,buffer[m]);
  236.             strcpy(buffer[m],buffer[m+1]);
  237.             strcpy(buffer[m+1],z); i = FALSE;
  238.          }
  239.       }
  240.       if(i) break;
  241.    }
  242. /* ---------- end sorting ------------- */
  243.    UnLock(actdir);
  244.    FreeMem(dirinfo,sizeof(struct FileInfoBlock));
  245. }
  246.  
  247. /* --------------------------------------------------------------
  248.    Draw a border for prop gadgets
  249.    -------------------------------------------------------------- */
  250. void DrawPropBorder(gadget,window)
  251. struct Gadget *gadget;
  252. struct Window *window;
  253. {
  254. int sx,sy,ex,ey;
  255. struct RastPort *rp;
  256.  
  257.    rp = window->RPort;
  258.    sx = gadget->LeftEdge;
  259.    sy = gadget->TopEdge;
  260.    ex = sx + gadget->Width - 1;
  261.    ey = sy + gadget->Height - 1;
  262.    SetAPen(rp,0);
  263.    Move(rp,sx,sy);   Draw(rp,sx,ey);
  264.    SetAPen(rp,1);
  265.    Move(rp,sx+1,ey); Draw(rp,sx+1,sy);
  266.                      Draw(rp,ex,sy);
  267.    SetAPen(rp,0);
  268.    Move(rp,ex,sy);   Draw(rp,ex,ey);
  269.    SetAPen(rp,2);
  270.    Move(rp,ex-1,sy); Draw(rp,ex-1,ey);
  271.                      Draw(rp,sx+1,ey);
  272. }
  273.  
  274. /* --------------------------------------------------------------
  275.    only refresh ONE gadget
  276.    -------------------------------------------------------------- */
  277. void Refresh1Gadget(gadget,window)
  278. struct Gadget *gadget;
  279. struct Window *window;
  280. {
  281. struct Gadget *nextgad;
  282.  
  283.    nextgad = gadget->NextGadget;
  284.    gadget->NextGadget = NULL;
  285.    RefreshGadgets(gadget,window,NULL);
  286.    if(gadget->GadgetType == PROPGADGET) DrawPropBorder(gadget,window);
  287.    gadget->NextGadget = nextgad;
  288. }
  289.  
  290. /* --------------------------------------------------------------
  291.    initialize NewWindow structure
  292.    -------------------------------------------------------------- */
  293. struct NewWindow *init_window(x,y,title,pen1,pen2)
  294. int x,y,pen1,pen2;
  295. char *title;
  296. {
  297. struct NewWindow *window;
  298. char *strptr;
  299. int left, top, wbwidth, wbheight;
  300.  
  301.    if(GfxBase == NULL) GfxBase = 
  302.          (struct GfxBase *)OpenLibrary("graphics.library",0);
  303.    if(IntuitionBase == NULL) IntuitionBase = 
  304.           (struct IntuitionBase *) OpenLibrary("intuition.library",0);
  305.    if(WBScreen == NULL) WBScreen = (struct Screen *)OpenWorkBench();
  306.    wbwidth = WBScreen->Width;
  307.    wbheight = WBScreen->Height;
  308.    left = (wbwidth - x) / 2;
  309.    top = (wbheight - y) / 2;
  310.    if(left <= 0) {left = 1; x = wbwidth - 2;}
  311.    if(top <= 0) {top = 1; y = wbheight -2;}
  312.  
  313.    window = (struct NewWindow *) malloc(sizeof(struct NewWindow));
  314.    strptr = (char *) tree_alloc(strlen(title)+1); strcpy(strptr,title);
  315.    window->LeftEdge = left;
  316.    window->TopEdge = top;
  317.    window->Width = x;
  318.    window->Height = y;
  319.    window->DetailPen = pen1;
  320.    window->BlockPen = pen2;
  321.    window->IDCMPFlags =
  322. CLOSEWINDOW | GADGETDOWN | GADGETUP  | MENUPICK | NEWSIZE;
  323.    window->Flags = 
  324. SMART_REFRESH | WINDOWCLOSE | WINDOWDRAG | WINDOWDEPTH | WINDOWSIZING;
  325.    window->FirstGadget = NULL;
  326.    window->CheckMark = NULL;
  327.    window->Title = (UBYTE *) strptr;
  328.    window->Screen = WBScreen;
  329.    window->BitMap = NULL;
  330.    window->MinWidth = 150;
  331.    window->MinHeight = 100;
  332.    window->MaxWidth = 720;
  333.    window->MaxHeight = 560;
  334.    window->Type = WBENCHSCREEN;
  335.    if(WBScreen->Flags & CUSTOMSCREEN) window->Type = CUSTOMSCREEN;
  336.    return(window);
  337. }
  338.  
  339. /* -------------------------------------------------------------
  340.    open a window and return structure
  341.    ------------------------------------------------------------- */
  342. struct Window *open_win(x,y,title,pen1,pen2)
  343. int x,y,pen1,pen2;
  344. char *title;
  345. {
  346. struct NewWindow *new_window;
  347. struct Window *main_window;
  348.  
  349.    new_window = init_window(x,y,title,pen1,pen2);
  350.    main_window = (struct Window *) OpenWindow(new_window);
  351.    free(new_window);
  352.    return(main_window);
  353. }
  354.  
  355. /* -------------------------------------------------------------
  356.    initialize gadget structure
  357.    ------------------------------------------------------------- */
  358. struct Gadget *init_gadget(x,y,flg,act,type,my_text,window)
  359. int x,y;
  360. USHORT flg,act,type;
  361. struct IntuiText *my_text;
  362. struct NewWindow *window;
  363. {
  364. struct Gadget *my_gadget;
  365.    my_gadget = (struct Gadget *) tree_alloc(sizeof(struct Gadget));
  366.    my_gadget->NextGadget = window->FirstGadget;
  367.    my_gadget->LeftEdge = acc_x;
  368.    my_gadget->TopEdge = acc_y;
  369.    my_gadget->Width = x;
  370.    my_gadget->Height = y;
  371.    my_gadget->Flags = flg;
  372.    my_gadget->Activation = act;
  373.    my_gadget->GadgetType = type;
  374.    my_gadget->GadgetRender = NULL;
  375.    my_gadget->SelectRender = NULL;
  376.    my_gadget->GadgetText = my_text;
  377.    my_gadget->MutualExclude = 0;
  378.    my_gadget->SpecialInfo = NULL;
  379.    my_gadget->GadgetID = fn_number;
  380.    my_gadget->UserData = NULL;
  381.  
  382.    window->FirstGadget = my_gadget;
  383.    return(my_gadget);
  384. }
  385.  
  386. /* --------------------------------------------------------------
  387.    initialize intuition text structure
  388.    -------------------------------------------------------------- */
  389. struct IntuiText *init_textstruct(left,top)
  390. int top,left;
  391. {
  392. struct IntuiText *my_text;
  393.  
  394.    my_text = (struct IntuiText *) tree_alloc(sizeof(struct IntuiText));
  395.    my_text->FrontPen = 1;
  396.    my_text->BackPen = 0;
  397.    my_text->DrawMode = JAM1;
  398.    my_text->LeftEdge = left;
  399.    my_text->TopEdge = top;
  400.    my_text->ITextFont = &topaz_font;
  401.    my_text->IText = NULL;
  402.    my_text->NextText = NULL;
  403.    return(my_text);
  404. }
  405.  
  406. struct IntuiText *init_text(title,left,top)
  407. char *title;
  408. int top,left;
  409. {
  410. struct IntuiText *my_text;
  411. char  *strptr;
  412.  
  413.    my_text = init_textstruct(left,top);
  414.    strptr = (char *) tree_alloc(strlen(title)+1); strcpy(strptr,title);
  415.    my_text->IText = (UBYTE *) strptr;
  416.    return(my_text);
  417. }
  418. /* --------------------------------------------------------------
  419.    add border to gadget
  420.    -------------------------------------------------------------- */
  421.  
  422. void add_border(gadget,x,y)
  423. struct Gadget *gadget;
  424. int x,y;
  425. {
  426. SHORT *my_points1, *my_points2;
  427. struct Border *my_border1, *my_border2, *my_border3, *my_border4;
  428.  
  429.    my_points1 = (SHORT *) tree_alloc(20);
  430.    my_points2 = (SHORT *) tree_alloc(20);
  431.    my_border1 = (struct Border *) tree_alloc(sizeof(struct Border));
  432.    my_border2 = (struct Border *) tree_alloc(sizeof(struct Border));
  433.    my_border3 = (struct Border *) tree_alloc(sizeof(struct Border));
  434.    my_border4 = (struct Border *) tree_alloc(sizeof(struct Border));
  435.  
  436.    my_points1[0] = x+1 ; my_points1[1] = 0 ;
  437.    my_points1[2] = 0   ; my_points1[3] = 0 ;
  438.    my_points1[4] = 0   ; my_points1[5] = y+1 ;
  439.  
  440.    my_points2[0] = x+1 ; my_points2[1] = 0 ;
  441.    my_points2[2] = x+1 ; my_points2[3] = y+1 ;
  442.    my_points2[4] = 0   ; my_points2[5] = y+1 ;
  443.  
  444.    my_border1->LeftEdge = -1;
  445.    my_border1->TopEdge = -1;
  446.    my_border1->FrontPen = 2;
  447.    my_border1->BackPen = 0;
  448.    my_border1->DrawMode = JAM1;
  449.    my_border1->Count = 3;
  450.    my_border1->XY = my_points1;
  451.    my_border1->NextBorder = my_border2;
  452.  
  453.    my_border2->LeftEdge = -1;
  454.    my_border2->TopEdge = -1;
  455.    my_border2->FrontPen = 1;
  456.    my_border2->BackPen = 0;
  457.    my_border2->DrawMode = JAM1;
  458.    my_border2->Count = 3;
  459.    my_border2->XY = my_points2;
  460.    my_border2->NextBorder = NULL;
  461.  
  462.    my_border3->LeftEdge = -1;
  463.    my_border3->TopEdge = -1;
  464.    my_border3->FrontPen = 1;
  465.    my_border3->BackPen = 0;
  466.    my_border3->DrawMode = JAM1;
  467.    my_border3->Count = 3;
  468.    my_border3->XY = my_points1;
  469.    my_border3->NextBorder = my_border4;
  470.  
  471.    my_border4->LeftEdge = -1;
  472.    my_border4->TopEdge = -1;
  473.    my_border4->FrontPen = 2;
  474.    my_border4->BackPen = 0;
  475.    my_border4->DrawMode = JAM1;
  476.    my_border4->Count = 3;
  477.    my_border4->XY = my_points2;
  478.    my_border4->NextBorder = NULL;
  479.  
  480.    gadget->GadgetRender = (APTR) my_border1;
  481.    gadget->SelectRender = (APTR) my_border3;
  482. }
  483.  
  484. void add_border2(gadget,x,y)
  485. struct Gadget *gadget;
  486. int x,y;
  487. {
  488. SHORT *my_points1, *my_points2, *my_points3, *my_points4;
  489. struct Border *my_border1, *my_border2, *my_border3, *my_border4;
  490.  
  491.    my_points1 = (SHORT *) tree_alloc(20);
  492.    my_points2 = (SHORT *) tree_alloc(20);
  493.    my_points3 = (SHORT *) tree_alloc(20);
  494.    my_points4 = (SHORT *) tree_alloc(20);
  495.    my_border1 = (struct Border *) tree_alloc(sizeof(struct Border));
  496.    my_border2 = (struct Border *) tree_alloc(sizeof(struct Border));
  497.    my_border3 = (struct Border *) tree_alloc(sizeof(struct Border));
  498.    my_border4 = (struct Border *) tree_alloc(sizeof(struct Border));
  499.  
  500.    my_points1[0] = x+1 ; my_points1[1] = 0 ;
  501.    my_points1[2] = 0   ; my_points1[3] = 0 ;
  502.    my_points1[4] = 0   ; my_points1[5] = y+1 ;
  503.  
  504.    my_points2[0] = x+1 ; my_points2[1] = 0 ;
  505.    my_points2[2] = x+1 ; my_points2[3] = y+1 ;
  506.    my_points2[4] = 0   ; my_points2[5] = y+1 ;
  507.  
  508.    my_points3[0] = x+3 ; my_points3[1] = 0 ;
  509.    my_points3[2] = 0   ; my_points3[3] = 0 ;
  510.    my_points3[4] = 0   ; my_points3[5] = y+3 ;
  511.  
  512.    my_points4[0] = x+3 ; my_points4[1] = 0 ;
  513.    my_points4[2] = x+3 ; my_points4[3] = y+3 ;
  514.    my_points4[4] = 0   ; my_points4[5] = y+3 ;
  515.  
  516.    my_border1->LeftEdge = -1;
  517.    my_border1->TopEdge = -1;
  518.    my_border1->FrontPen = 1;
  519.    my_border1->BackPen = 0;
  520.    my_border1->DrawMode = JAM1;
  521.    my_border1->Count = 3;
  522.    my_border1->XY = my_points1;
  523.    my_border1->NextBorder = my_border2;
  524.  
  525.    my_border2->LeftEdge = -1;
  526.    my_border2->TopEdge = -1;
  527.    my_border2->FrontPen = 2;
  528.    my_border2->BackPen = 0;
  529.    my_border2->DrawMode = JAM1;
  530.    my_border2->Count = 3;
  531.    my_border2->XY = my_points2;
  532.    my_border2->NextBorder = my_border3;
  533.  
  534.    my_border3->LeftEdge = -2;
  535.    my_border3->TopEdge = -2;
  536.    my_border3->FrontPen = 2;
  537.    my_border3->BackPen = 0;
  538.    my_border3->DrawMode = JAM1;
  539.    my_border3->Count = 3;
  540.    my_border3->XY = my_points3;
  541.    my_border3->NextBorder = my_border4;
  542.  
  543.    my_border4->LeftEdge = -2;
  544.    my_border4->TopEdge = -2;
  545.    my_border4->FrontPen = 1;
  546.    my_border4->BackPen = 0;
  547.    my_border4->DrawMode = JAM1;
  548.    my_border4->Count = 3;
  549.    my_border4->XY = my_points4;
  550.    my_border4->NextBorder = NULL;
  551.  
  552.    gadget->GadgetRender = (APTR) my_border1;
  553. }
  554.  
  555.  
  556. void add_xprop(title,min,max,window,flag)
  557. int min,max;
  558. char *title;
  559. struct NewWindow *window;
  560. int flag;
  561. {
  562. char s[40];
  563. struct IntuiText *my_text, *my_value;
  564. struct Image *my_image;
  565. struct PropInfo *my_prop_info;
  566. struct Gadget *my_gadget;
  567.  
  568.    scale_var0[fn_number]=min;
  569.    scale_var1[fn_number]=max;
  570.  
  571.    my_image = (struct Image *) tree_alloc(sizeof(struct Image));
  572.  
  573.    if(flag == 1) {
  574.       sprintf(s,"%d",min);
  575.       my_value = init_text(s,10,-10);
  576.       my_text = init_text(title,0,12);
  577.       my_text->NextText = my_value;
  578.    } else {
  579.       my_text = NULL;
  580.    }
  581.  
  582.    my_prop_info = (struct PropInfo *) tree_alloc(sizeof(struct PropInfo));
  583.    my_prop_info->Flags = FREEHORIZ | AUTOKNOB;
  584.    my_prop_info->HorizPot = 0;
  585.    my_prop_info->VertPot = 0;
  586.    my_prop_info->HorizBody = MAXBODY / 100;
  587.    my_prop_info->VertBody = 0;
  588.  
  589.    my_gadget = 
  590. init_gadget(100,10,GADGHCOMP,GADGIMMEDIATE|RELVERIFY,PROPGADGET,my_text,window);
  591.    my_gadget->GadgetRender = (APTR) my_image;
  592.    my_gadget->SpecialInfo = (APTR) my_prop_info;
  593.  
  594.    *var_value[fn_number] = min;
  595. }
  596.  
  597. /* --------------------------------------------------------------
  598.    add a proportional gadget to the window structure
  599.    -------------------------------------------------------------- */
  600. void add_yprop(title,min,max,window,flag)
  601. int min,max;
  602. char *title;
  603. struct NewWindow *window;
  604. int flag;
  605. {
  606. struct PropInfo *my_prop_info;
  607. struct Gadget *my_gadget;
  608.  
  609.    add_xprop(title,min,max,window,flag);
  610.                                /* OK, not the finest style, but very efficient */
  611.    my_gadget = window->FirstGadget;
  612.    my_prop_info = (struct PropInfo *) my_gadget->SpecialInfo;
  613.  
  614.    my_prop_info->Flags = FREEVERT | AUTOKNOB;
  615.    my_prop_info->VertBody = MAXBODY / 100 ;
  616.    my_prop_info->HorizBody = 0;
  617.  
  618.    my_gadget->Width = 13;
  619.    my_gadget->Height = 100;
  620. }
  621.  
  622.  
  623. void CallBack_prop(gadget,window) /* no display of value */
  624. struct Gadget *gadget;
  625. struct Window *window;
  626. {
  627. struct PropInfo *my_prop_info;
  628. int gadgetid;
  629. int n;
  630. int type,max,min;
  631.  
  632.    gadgetid = gadget->GadgetID; type = var_funct[gadgetid];
  633.    my_prop_info = (struct PropInfo *) gadget->SpecialInfo;
  634.    if(type == SCALEY00) {
  635.       n = my_prop_info->VertPot;
  636.    } else {
  637.       n = my_prop_info->HorizPot;
  638.    }
  639.    max=scale_var1[gadgetid]; min=scale_var0[gadgetid];
  640.    n = min + (((max - min) * n) / MAXPOT);
  641.    *var_value[gadgetid] = n;
  642.    DrawPropBorder(gadget,window);
  643. }
  644.  
  645.  
  646. void CallBack_disp_prop(gadget,window) /* display value */
  647. struct Gadget *gadget;
  648. struct Window *window;
  649. {
  650. ULONG class;
  651. ULONG code;
  652. struct IntuiMessage *my_message;
  653. struct PropInfo *my_prop_info;
  654. struct IntuiText *my_text;
  655. struct RastPort *rp;
  656. char *strptr;
  657. int gadgetid;
  658. int n,m,x,y;
  659. int type,max,min;
  660.  
  661.    rp = window->RPort;
  662.    x = gadget->LeftEdge;
  663.    y = gadget->TopEdge;
  664.  
  665.    gadgetid = gadget->GadgetID; type = var_funct[gadgetid]; m=129845;
  666.    my_prop_info = (struct PropInfo *) gadget->SpecialInfo;
  667.    while(1==1) {
  668.       my_message=(struct IntuiMessage *)GetMsg(window->UserPort);
  669.       if(my_message) {
  670.          class = my_message->Class;      /* Save the IDCMP flag. */
  671.          code = my_message->Code;
  672.          ReplyMsg( my_message );
  673.          if( class = GADGETUP ) return;
  674.        }
  675.  
  676.       if((type == SCALEY) || (type == SCALEY11)) {
  677.          n = my_prop_info->VertPot;
  678.       } else {
  679.          n = my_prop_info->HorizPot;
  680.       }
  681.       max=scale_var1[gadgetid]; min=scale_var0[gadgetid];
  682.       n = min + (((max - min) * n) / MAXPOT);
  683.       if(m!=n) {
  684.          my_text = gadget->GadgetText; my_text = my_text->NextText;
  685.          my_text->FrontPen = 0; PrintIText(rp,my_text,x,y);
  686.          strptr = (char *) my_text->IText; sprintf(strptr,"%d",n);
  687.          my_text->FrontPen = 1; PrintIText(rp,my_text,x,y);
  688.                                 DrawPropBorder(gadget,window);
  689.          *var_value[gadgetid] = n;
  690.       }
  691.    }
  692. }
  693.  
  694. void DrawAllPropBorders(window)
  695. struct Window *window;
  696. {
  697. struct Gadget *gadget;
  698.  
  699.    gadget = window->FirstGadget;
  700.    while(gadget != NULL) {
  701.       gadget = gadget->NextGadget;
  702.       if(gadget->GadgetType == PROPGADGET) DrawPropBorder(gadget,window);
  703.    }
  704. }
  705.    
  706.  
  707. /* --------------------------------------------------------------
  708.    add toggle button to window
  709.    -------------------------------------------------------------- */
  710. void add_toggle(title,window)
  711. char *title;
  712. struct NewWindow *window;
  713. {
  714. struct IntuiText *my_text;
  715. struct Gadget *my_gadget;
  716.  
  717.    my_text = init_text(title,10,0);
  718.  
  719.    my_gadget = 
  720. init_gadget(7,7,GADGHCOMP,TOGGLESELECT|GADGIMMEDIATE,BOOLGADGET,my_text,window);
  721.    add_border(my_gadget,7,7);
  722.    *var_value[fn_number] = 0;
  723. }
  724.  
  725. void CallBack_toggle(gadget,window)
  726. struct Gadget *gadget;
  727. struct Window *window;
  728. {
  729. int gadgetid;
  730. int n;
  731.  
  732.    gadgetid = gadget->GadgetID;
  733.    *var_value[gadgetid] = 0;
  734.    if(gadget->Flags & SELECTED) *var_value[gadgetid] = 1;
  735. }
  736.  
  737. void add_string(title,window)
  738. char *title;
  739. struct NewWindow *window;
  740. {
  741. int n;
  742. struct IntuiText *my_text;
  743. struct StringInfo *my_string_info;
  744. struct Gadget *my_gadget;
  745. UBYTE *buf, *undobuf;
  746.  
  747.    my_text = init_text(title,0,12);
  748.  
  749.    buf = (UBYTE *) tree_alloc(100); for(n=0;n<100;n++) buf[n]=0;
  750.    undobuf = (UBYTE *) tree_alloc(100); for(n=0;n<100;n++) undobuf[n]=0;
  751.    my_string_info = (struct StringInfo *) tree_alloc(sizeof(struct StringInfo));
  752.    my_string_info->Buffer = buf;
  753.    my_string_info->UndoBuffer = undobuf;
  754.    my_string_info->BufferPos = 0;
  755.    my_string_info->MaxChars = 99;
  756.    my_string_info->DispPos = 0;
  757.  
  758.    my_gadget =
  759. init_gadget(100,10,GADGHCOMP,RELVERIFY,STRGADGET,my_text,window);
  760.    my_gadget->SpecialInfo = (APTR) my_string_info;
  761.    add_border2(my_gadget,100,10);
  762. }
  763.  
  764. void add_integer(title,window)   /* NEW! */
  765. char *title;
  766. struct NewWindow *window;
  767. {
  768. struct Gadget *my_gadget;
  769.  
  770.    add_string(title,window);
  771.    my_gadget = window->FirstGadget;
  772.    my_gadget->Activation = my_gadget->Activation | LONGINT;
  773. }
  774.  
  775. void add_float(title,window)    /* NEW! */
  776. char *title;
  777. struct NewWindow *window;
  778. {
  779. struct Gadget *my_gadget;
  780.  
  781.    add_string(title,window);
  782.    my_gadget = window->FirstGadget;
  783.    my_gadget->Activation = my_gadget->Activation | STRINGRIGHT;
  784. }
  785.  
  786. void CallBack_string(gadget,window)  /* NEW! (modified) */
  787. struct Gadget *gadget;
  788. struct Window *window;
  789. {
  790. struct StringInfo *my_string_info;
  791. struct StringInfo *path_info;
  792. struct Gadget  *gg, *path;
  793. char *strptr, *pathptr;
  794. char *s;
  795. int gadgetid;
  796. int i,n;
  797.  
  798.    s = (char *) malloc(256);
  799.  
  800.    gadgetid = gadget->GadgetID;
  801.  
  802.    my_string_info = (struct StringInfo *) gadget->SpecialInfo;
  803.  
  804.    strptr = (char *) my_string_info->Buffer; strcpy(s,strptr);
  805.    if(gadget->Activation == RELVERIFY) {  /* simple string gadget */
  806.       if(var_funct[gadgetid] == FILE_SELECT) { /* special treatment for file selector box */
  807.          gg = (struct Gadget *) gadget->UserData;
  808.          for(i = 0; i < 5; i++) gg = gg->NextGadget;
  809.          path = (struct Gadget *) gg->UserData;
  810.          path_info = (struct StringInfo *) path->SpecialInfo;
  811.          pathptr = (char *) path_info->Buffer;
  812.          if((_instr(":",strptr) > 0) || (_instr("/",strptr) > 0)) {
  813.             strcpy(s,strptr);
  814.          } else {
  815.          strcpy(s,pathptr);
  816.          if((strlen(s) > 0) && (s[strlen(s)-1] != ':')) strcat(s,"/");
  817.          i = strlen(s); n=0; if(strptr[0] == 32) n = 1;
  818.          while(strptr[n] > 32) s[i++] = strptr[n++]; s[i]=0;
  819.          }
  820.       }
  821.       strcpy(var_value[gadgetid],s);
  822.    }
  823.    if(gadget->Activation & LONGINT) {     /* integer gadget */
  824.       *var_value[gadgetid] = atoi(strptr);
  825.    }
  826.    if(gadget->Activation & STRINGRIGHT) { /* floating point gadget */
  827.       sscanf(strptr,"%f",var_value[gadgetid]);
  828.    }
  829.    free(s);
  830.    last_gadgetid = gadgetid;
  831.    if(gadgetid < 150) (*fn_command[gadgetid])();
  832. }
  833.  
  834.  
  835. void add_push(title,window)
  836. char *title;
  837. struct NewWindow *window;
  838. {
  839. int n,l;
  840. struct IntuiText *my_text;
  841. struct Gadget *my_gadget;
  842.  
  843.    my_text = init_text(title,0,0);
  844.    l = strlen(title); n = 2 + ( l * 8 );
  845.  
  846.    my_gadget =
  847. init_gadget(n,9,GADGHIMAGE,GADGIMMEDIATE|RELVERIFY,BOOLGADGET,my_text,window);
  848.    add_border(my_gadget,n,9);
  849. }
  850.  
  851. void CallBack_push(gadget,window)
  852. struct Gadget *gadget;
  853. struct Window *window;
  854. {
  855. int gadgetid;
  856.  
  857.    gadgetid = gadget->GadgetID;
  858.    if(gadgetid < 150) (*fn_command[gadgetid])();
  859. }
  860.  
  861.  
  862. void add_new_menu(title)
  863. char *title;
  864. {
  865. int n,l;
  866. char *my_text;
  867. struct Menu *my_menu;
  868.  
  869.    l = strlen(title); n = ( 8 * l ) + 15;
  870.    my_text = (char *)malloc(l+1); strcpy(my_text,title);
  871.  
  872.    my_menu = (struct Menu*)malloc(sizeof(struct Menu));
  873.    my_menu->NextMenu = menu_bar;
  874.    my_menu->LeftEdge = menu_column; menu_column = menu_column + n;
  875.    my_menu->TopEdge = 0;
  876.    my_menu->Width = n;
  877.    my_menu->Height = 10;
  878.    my_menu->Flags = MENUENABLED;
  879.    my_menu->MenuName = my_text;
  880.    my_menu->FirstItem = NULL;
  881.  
  882.    menu_bar = my_menu;
  883.    menu_line = 0;
  884. }
  885.  
  886.  
  887. void add_menu(title)
  888. char *title;
  889. {
  890. struct IntuiText *my_text, *my_value;
  891. struct MenuItem *my_item;
  892.  
  893.    my_value = init_textstruct(fn_number,0);
  894.    my_text = init_text(title,0,1);
  895.    my_text->FrontPen = 2;
  896.    my_text->NextText = my_value;
  897.  
  898.    my_item = (struct MenuItem *)malloc(sizeof(struct MenuItem));
  899.    my_item->NextItem = menu_bar->FirstItem;
  900.    my_item->LeftEdge = 0;
  901.    my_item->TopEdge = menu_line; menu_line = menu_line + 10;
  902.    my_item->Width = 150;
  903.    my_item->Height = 10;
  904.    my_item->Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP;
  905.    my_item->MutualExclude = 0;
  906.    my_item->ItemFill = (APTR) my_text;
  907.    my_item->SelectFill = NULL;
  908.    my_item->Command = 0;
  909.    my_item->SubItem = NULL;
  910.    my_item->NextSelect = MENUNULL;
  911.    menu_bar->FirstItem = my_item;
  912. }
  913.  
  914. void CallBack_menu(menu_number)
  915. int menu_number;
  916. {
  917. struct MenuItem *item;
  918. struct IntuiText *my_text, *my_value;
  919. int n;
  920. char *str;
  921.  
  922.    item = (struct MenuItem *) ItemAddress(menu_bar,menu_number);
  923.    if(item == NULL) return;
  924.    my_text = (struct IntuiText *)item->ItemFill;
  925.    str = (char *) my_text->IText;
  926.    my_value = my_text->NextText;
  927.    n = my_value->LeftEdge;
  928.    last_gadgetid = n;
  929.    if((n>0) && (n < 150)) (*fn_command[n])();
  930. }
  931.  
  932.  
  933. /* -----------------------------------------------------------
  934.          Unterroutine zum Abschluss des Programm 
  935.    ----------------------------------------------------------- */
  936. void close_gfx(struct Window *my_window)
  937. {
  938.   if(my_window != NULL) CloseWindow(my_window);
  939.   CloseLibrary(GfxBase);
  940.   CloseLibrary(IntuitionBase);
  941. }
  942.  
  943.  
  944. /* -------------------------------------------------------------
  945.    create a simple requester with a message
  946.    ------------------------------------------------------------- */
  947. void Help(message)
  948. char *message;
  949. {
  950. struct Window *helpwin;
  951. struct RastPort *rp;
  952. char c,s[80];
  953. int l,ml,n,i;
  954. int   x,y;
  955. BOOL close_me;
  956. ULONG class;
  957. ULONG code;
  958. struct IntuiMessage *my_message;
  959.  
  960.   close_me = FALSE;
  961.  
  962.    ml=0 ; l=0; n=1; c=32; i=0;
  963.    while(c!=0) {
  964.       c = message[i++];
  965.       if(c == 0) break;
  966.       if(c == 10) {
  967.          n++; if(l > ml) ml = l;
  968.          l = 0;
  969.       }
  970.       l++;
  971.    }
  972.    n = 30 + n * 10; /* number of lines needed */
  973.    ml = 30 + ml * 8; /* number of columns needed */
  974.  
  975.    helpwin = open_win(ml,n,"message:",0,3); rp = helpwin->RPort;
  976.    SetDrMd(rp,JAM1); SetAPen(rp,2); RectFill(rp,2,10,ml-2,n-2); SetAPen(rp,1);
  977.    x = 10 ; y = 30;
  978.  
  979.  
  980.    c=32; i=0; n=0;
  981.    while(c!=0) {
  982.       c = message[i++];
  983.       if(c <= 10) {
  984.          s[n] = 0;
  985.          Move(rp,x,y);
  986.          Text(rp,s,n);
  987.          n = 0; y = y + 10;
  988.          continue;
  989.       }
  990.       s[n++] = c;
  991.    }
  992.    while(!((*((UBYTE*)0xbfe001))&64)); /* wait for release of mouse button */
  993.    while(1 == 1) {
  994.       Delay(5L);
  995.       while(my_message=(struct IntuiMessage *)GetMsg(helpwin->UserPort)) {
  996.          class = my_message->Class;      /* Save the IDCMP flag. */
  997.          code = my_message->Code;
  998.          ReplyMsg( my_message );
  999.          switch( class ) {
  1000.             case CLOSEWINDOW:  /* The user selected the Close window gadget! */
  1001.                close_me=TRUE;
  1002.                break;       
  1003.          }
  1004.       }
  1005.       if(close_me == TRUE) break;
  1006.       if(!((*((UBYTE*)0xbfe001))&64)) break; /*left mouse button ? */
  1007.    }
  1008.    close_gfx(helpwin);
  1009. }
  1010.  
  1011. /* *************************************************************
  1012.    selector box and fileselector box
  1013.    ************************************************************* */
  1014. struct Gadget *create_selector(x,y,b,title,window,items,fn)
  1015. char *title;
  1016. char **items;
  1017. int x,y,b,fn;
  1018. struct NewWindow *window;
  1019. {
  1020. struct Gadget *choiceg;
  1021. struct Gadget *slide;
  1022. struct Gadget *result;
  1023. struct Gadget *accept;
  1024. struct Gadget *cancel;
  1025. struct IntuiText *my_text;
  1026. struct Image *my_image;
  1027. struct PropInfo *my_prop_info;
  1028. struct StringInfo *my_string_info;
  1029. int n,m;
  1030. UBYTE *buf, *undobuf;
  1031.  
  1032.    m = 2 + ( b * 8 );
  1033.  
  1034. /* stringbox */
  1035.    my_text = init_text(title,0,-84);
  1036.    buf = (UBYTE *) tree_alloc(100); for(n=0;n<100;n++) buf[n]=0;
  1037.    undobuf = (UBYTE *) tree_alloc(100); for(n=0;n<100;n++) undobuf[n]=0;
  1038.    my_string_info = (struct StringInfo *) tree_alloc(sizeof(struct StringInfo));
  1039.    my_string_info->Buffer = buf;
  1040.    my_string_info->UndoBuffer = undobuf;
  1041.    my_string_info->BufferPos = 0;
  1042.    my_string_info->MaxChars = 99;
  1043.    my_string_info->DispPos = 0;
  1044.  
  1045.    result =
  1046. init_gadget(m,10,GADGHCOMP,RELVERIFY,STRGADGET,my_text,window);
  1047.    result->SpecialInfo = (APTR) my_string_info;
  1048.    result->LeftEdge = x ;
  1049.    result->TopEdge = y + 96 ;
  1050.    result->GadgetID = fn ;
  1051.    add_border2(result,m,10);
  1052.  
  1053. /* 7 push buttons for text window */
  1054.    for(n=7;n>0;n--) {
  1055.       my_text = init_textstruct(0,0); my_text->IText = (UBYTE *) items[n-1];
  1056.       choiceg = init_gadget(m,10,GADGHNONE,GADGIMMEDIATE,BOOLGADGET,my_text,window);
  1057.       choiceg->LeftEdge = x ;
  1058.       choiceg->TopEdge = y + (10*n) + 12 ;
  1059.       choiceg->GadgetID = SELBOXGAD ;
  1060.    }
  1061.    add_border(choiceg,m,70);
  1062.  
  1063. /* slider */
  1064.    my_image = (struct Image *) tree_alloc(sizeof(struct Image));
  1065.    my_prop_info = (struct PropInfo *) tree_alloc(sizeof(struct PropInfo));
  1066.    my_prop_info->Flags = FREEVERT | AUTOKNOB;
  1067.    my_prop_info->HorizPot = 0;
  1068.    my_prop_info->VertPot = 0;
  1069.    my_prop_info->HorizBody = 0;
  1070.    my_prop_info->VertBody = MAXBODY / 100;
  1071.    slide = 
  1072. init_gadget(13,70,GADGHCOMP,GADGIMMEDIATE|RELVERIFY,PROPGADGET,NULL,window);
  1073.    slide->GadgetRender = (APTR) my_image;
  1074.    slide->SpecialInfo = (APTR) my_prop_info;
  1075.    slide->GadgetID = SPECIALPRO ;
  1076.    slide->LeftEdge = x+m+2;
  1077.    slide->TopEdge = y+22;
  1078.    slide->UserData = (APTR) items;
  1079.  
  1080. /* ok button */
  1081.    my_text = init_text("OK",0,0);
  1082.    accept = 
  1083.    init_gadget(18,10,GADGHIMAGE,GADGIMMEDIATE|RELVERIFY,BOOLGADGET,my_text,window);
  1084.    accept->LeftEdge = x ;
  1085.    accept->TopEdge = y + 110 ;
  1086.    accept->GadgetID = SPECIALOK ;
  1087.    add_border(accept,18,10);
  1088.  
  1089. /* cancel button */
  1090.    my_text = init_text("CANCEL",0,0);
  1091.    cancel = 
  1092.    init_gadget(50,10,GADGHIMAGE,GADGIMMEDIATE|RELVERIFY,BOOLGADGET,my_text,window);
  1093.    cancel->LeftEdge = x + 40;
  1094.    cancel->TopEdge = y + 110 ;
  1095.    cancel->GadgetID = SPECIALCAN ;
  1096.    add_border(cancel,50,10);
  1097.  
  1098.    result->UserData = (APTR) slide;     /* IMPORTANT !!! */
  1099.  
  1100.    return(result);
  1101. }
  1102.  
  1103. /* ------------------------------------------------
  1104.    create a file selector box
  1105.    ------------------------------------------------ */
  1106. struct Gadget *create_fselect(x,y,b,title,window,items,fn)
  1107. char *title;
  1108. char **items;
  1109. int x,y,b,fn;
  1110. struct NewWindow *window;
  1111. {
  1112. struct Gadget *gg;
  1113. struct Gadget *strbox;
  1114. struct Gadget *slide;
  1115. struct Gadget *choice;
  1116. struct Gadget *parent;
  1117. struct IntuiText *my_text;
  1118. struct StringInfo *my_string_info;
  1119. int n,m;
  1120. UBYTE *buf, *undobuf;
  1121.  
  1122.       m = 2 + ( b * 8 );
  1123.  
  1124.    gg = create_selector(x,y+1,b,title,window,items,fn);
  1125.    slide = (struct Gadget *) gg->UserData;
  1126.    choice = slide->NextGadget;
  1127.  
  1128. /* add another stringbox */
  1129.    buf = (UBYTE *) tree_alloc(200); for(n=0;n<200;n++) buf[n]=0;
  1130.    undobuf = (UBYTE *) tree_alloc(200); for(n=0;n<200;n++) undobuf[n]=0;
  1131.    my_string_info = (struct StringInfo *) tree_alloc(sizeof(struct StringInfo));
  1132.    my_string_info->Buffer = buf;
  1133.    my_string_info->UndoBuffer = undobuf;
  1134.    my_string_info->BufferPos = 0;
  1135.    my_string_info->MaxChars = 99;
  1136.    my_string_info->DispPos = 0;
  1137.  
  1138.    strbox =
  1139. init_gadget(m,10,GADGHCOMP,RELVERIFY,STRGADGET,NULL,window);
  1140.    strbox->SpecialInfo = (APTR) my_string_info;
  1141.    strbox->LeftEdge = x ;
  1142.    strbox->TopEdge = y ;
  1143.    strbox->GadgetID = FSELSTRING ;
  1144.    strbox->UserData = (APTR) slide;        /* IMPORTANT !!! */
  1145.    add_border2(strbox,m,10);
  1146.  
  1147.    for(n=0;n<7;n++) {
  1148.       choice->UserData = (APTR) strbox;    /* IMPORTANT !!! */
  1149.       choice->GadgetID = FSELBOXGAD;
  1150.       choice = choice->NextGadget;
  1151.    }
  1152.  
  1153. /* add Parent Button */
  1154.  
  1155.    my_text = init_text("Parent",0,0);
  1156.    parent = 
  1157.    init_gadget(50,10,GADGHIMAGE,GADGIMMEDIATE|RELVERIFY,BOOLGADGET,my_text,window);
  1158.    parent->LeftEdge = x + m - 50 ;
  1159.    parent->TopEdge = y + 111 ; /* should be 110, WB 2.0 ? */
  1160.    parent->GadgetID = SPECIALPAR ;
  1161.    add_border(parent,50,10);
  1162.  
  1163.    return(gg);
  1164. }
  1165.  
  1166. /* ------------------------------------------
  1167.    call back functions for selection boxes
  1168.    ------------------------------------------ */
  1169. void CallBack_OK(gadget,window)
  1170. struct Gadget *gadget;
  1171. struct Window *window;
  1172. {
  1173. struct StringInfo *my_string_info;
  1174. struct StringInfo *path_info;
  1175. struct Gadget *result;
  1176. struct Gadget *path;
  1177. char *strptr, *pathptr;
  1178. char *s;
  1179. int gadgetid;
  1180. int i,n;
  1181.  
  1182.    s = (char *) malloc(256);
  1183.  
  1184.    result = gadget->NextGadget;
  1185.    while(1==1) {
  1186.       if( result->GadgetType == STRGADGET ) break;
  1187.       result = result->NextGadget;
  1188.    }
  1189.  
  1190.    gadgetid = result->GadgetID;
  1191.    last_gadgetid = gadgetid;
  1192.  
  1193.    my_string_info = (struct StringInfo *) result->SpecialInfo;
  1194.    strptr = (char *) my_string_info->Buffer; strcpy(s,strptr);
  1195.    if(var_funct[gadgetid] == FILE_SELECT) { /* special treatment for file selector box */
  1196.       result = gadget;
  1197.       while(result->GadgetID != FSELBOXGAD) result = result->NextGadget;
  1198.       path = (struct Gadget *) result->UserData;
  1199.       path_info = (struct StringInfo *) path->SpecialInfo;
  1200.       pathptr = (char *) path_info->Buffer;
  1201.       if((_instr(":",strptr) > 0) || (_instr("/",strptr) > 0)) {
  1202.          strcpy(s,strptr);
  1203.       } else {
  1204.          strcpy(s,pathptr);
  1205.          if((strlen(s) > 0) && (s[strlen(s)-1] != ':')) strcat(s,"/");
  1206.          i = strlen(s); n=0; if(strptr[0] == 32) n = 1;
  1207.          while(strptr[n] > 32) s[i++] = strptr[n++]; s[i]=0;
  1208.       }
  1209.    }
  1210.    strcpy(var_value[gadgetid],s);
  1211.    if(gadgetid < 150) (*fn_command[gadgetid])();
  1212.    free(s);
  1213. }
  1214.  
  1215. void CallBack_CAN(gadget,window)
  1216. struct Gadget *gadget;
  1217. struct Window *window;
  1218. {
  1219. struct Gadget *result;
  1220. int gadgetid;
  1221.  
  1222.    result = gadget->NextGadget;
  1223.    while(1==1) {
  1224.       if( result->GadgetType == STRGADGET ) break;
  1225.       result = result->NextGadget;
  1226.    }
  1227.  
  1228.    gadgetid = result->GadgetID;
  1229.  
  1230.    strcpy(var_value[gadgetid],"");
  1231.    if(gadgetid < 150) (*fn_command[gadgetid])();
  1232. }
  1233.  
  1234. void CallBack_SELBOX(gadget,window)
  1235. struct Gadget *gadget;
  1236. struct Window *window;
  1237. {
  1238. struct StringInfo *my_string_info;
  1239. struct IntuiText *my_text;
  1240. struct Gadget *result;
  1241. char *strptr, *textptr;
  1242. int gadgetid;
  1243.  
  1244.    my_text = gadget->GadgetText;
  1245.    textptr = (char *) my_text->IText;
  1246.  
  1247.    result = gadget->NextGadget;
  1248.    while(1==1) {
  1249.       if( result->GadgetType == STRGADGET ) break;
  1250.       result = result->NextGadget;
  1251.    }
  1252.  
  1253.    gadgetid = result->GadgetID;
  1254.  
  1255.    my_string_info = (struct StringInfo *) result->SpecialInfo;
  1256.  
  1257.    strptr = (char *) my_string_info->Buffer;
  1258.    if(strcmp(strptr,textptr)==0){         /* simple check for double click */
  1259.       CallBack_OK(gadget,window);
  1260.       return;
  1261.    }
  1262.    strcpy(strptr,textptr);
  1263.    Refresh1Gadget(result,window);
  1264. }
  1265.  
  1266. /* read dir-string, read directory, update string list */
  1267. void CallBack_FSELSTRING(gadget,window)
  1268. struct Gadget *gadget;
  1269. struct Window *window;
  1270. {
  1271. struct StringInfo *my_string_info;
  1272. struct IntuiText *my_text;
  1273. struct Gadget *slide;
  1274. struct Gadget *push;
  1275. char *strptr;
  1276. char **items;
  1277. char s[80];
  1278. int i;
  1279.  
  1280.    slide = (struct Gadget *) gadget->UserData;
  1281.    push = slide->NextGadget;
  1282.    for(i=0;i<7;i++) {
  1283.       my_text = push->GadgetText; my_text->FrontPen = 0;
  1284.       Refresh1Gadget(push,window);
  1285.       push = push->NextGadget;
  1286.    }
  1287.  
  1288.    items = (char **) slide->UserData;
  1289.  
  1290.    my_string_info = (struct StringInfo *) gadget->SpecialInfo;
  1291.  
  1292.    strptr = (char *) my_string_info->Buffer;
  1293.    strcpy(s,strptr);
  1294.    read_dir(s,items);
  1295.  
  1296.    push = slide->NextGadget;
  1297.    for(i=0;i<7;i++) {
  1298.       my_text = push->GadgetText; my_text->IText = (UBYTE *) items[i];
  1299.       if(items[i][0] == '/') {
  1300.          my_text->FrontPen = 2;
  1301.       } else {
  1302.          my_text->FrontPen = 1;
  1303.       }
  1304.       Refresh1Gadget(push,window);
  1305.       push = push->NextGadget;
  1306.    }
  1307. }
  1308.  
  1309. /* read string, update dir-box, read directory, update strings */
  1310. void CallBack_FSELBOX(gadget,window)
  1311. struct Gadget *gadget;
  1312. struct Window *window;
  1313. {
  1314. struct StringInfo *result_info;
  1315. struct StringInfo *path_info;
  1316. struct IntuiText *my_text;
  1317. struct Gadget *result;
  1318. struct Gadget *path;
  1319. char *strptr, *textptr, *pathptr;
  1320. int n,l;
  1321. char s[100];
  1322.  
  1323.    my_text = gadget->GadgetText;
  1324.    textptr = (char *) my_text->IText;
  1325.  
  1326.    result = gadget->NextGadget;
  1327.    while(1==1) {
  1328.       if( result->GadgetType == STRGADGET ) break;
  1329.       result = result->NextGadget;
  1330.    }
  1331.    path = (struct Gadget *) gadget->UserData;
  1332.    result_info = (struct StringInfo *) result->SpecialInfo;
  1333.    path_info = (struct StringInfo *) path->SpecialInfo;
  1334.    strptr = (char *) result_info->Buffer;
  1335.    pathptr = (char *) path_info->Buffer;
  1336.  
  1337.    if(textptr[0] == '/') {
  1338.       strcpy(s,pathptr);
  1339.       l=strlen(s); n=0;
  1340.       if(l==0) {
  1341.          n = 1;
  1342.       } else {
  1343.          if(s[l-1] == ':') n=1;
  1344.       }
  1345.       while(textptr[n] > 32) s[l++] = textptr[n++]; s[l]=0;
  1346.       strcpy(pathptr,s);
  1347.       Refresh1Gadget(path,window);
  1348.       CallBack_FSELSTRING(path,window); /* dirty trick, I know ! */
  1349.    } else {
  1350.       strcpy(s,textptr);
  1351.       if(strcmp(strptr,s)==0){         /* simple check for double click */
  1352.          CallBack_OK(gadget,window);
  1353.          return;
  1354.       }
  1355.       strcpy(strptr,s);
  1356.       Refresh1Gadget(result,window);
  1357.    }
  1358. }
  1359.  
  1360.  
  1361. void CallBack_PAR(gadget,window)
  1362. struct Gadget *gadget;
  1363. struct Window *window;
  1364. {
  1365. struct StringInfo *my_string_info;
  1366. struct IntuiText *my_text;
  1367. struct Gadget *slide;
  1368. struct Gadget *push;
  1369. struct Gadget *dirgad;
  1370. struct FileLock *actdir, *pardir;
  1371. struct FileInfoBlock *dirinfo;
  1372. char *strptr;
  1373. char **items;
  1374. char s[80];
  1375. int i,n,m,flag;
  1376.  
  1377.    dirgad = gadget->NextGadget;
  1378.    slide = dirgad->NextGadget;
  1379.    while(1==1) {
  1380.       if(slide->GadgetType == PROPGADGET ) break;
  1381.       slide = slide->NextGadget;
  1382.    }
  1383.    push = slide->NextGadget;
  1384.    for(i=0;i<7;i++) {
  1385.       my_text = push->GadgetText; my_text->FrontPen = 0;
  1386.       Refresh1Gadget(push,window);
  1387.       push = push->NextGadget;
  1388.    }
  1389.    items = (char **) slide->UserData;
  1390.    my_string_info = (struct StringInfo *) dirgad->SpecialInfo;
  1391.    strptr = (char *) my_string_info->Buffer;
  1392.    strcpy(s,strptr);
  1393.  
  1394.    i = strlen(s); flag = 0;
  1395.    while(i > 0) {
  1396.       if(s[i] == ':') {flag = 1 ; break;}
  1397.       if(s[i] == '/') {flag = 1 ; s[i] = 0; break;}
  1398.       s[i--] = 0;
  1399.    }
  1400.  
  1401.    if((i == 0) || (flag == 0)) {
  1402.       dirinfo = (struct FileInfoBlock *)AllocMem(sizeof(struct FileInfoBlock),0L);
  1403.       actdir = (struct FileLock *) Lock(s,-2);
  1404.       pardir = (struct FileLock *) ParentDir(actdir);
  1405.       n = Examine(pardir,dirinfo);
  1406.  
  1407.       m = 1; i = 0; s[0] = ':';
  1408.       while(m != 0) {
  1409.          m = dirinfo->fib_FileName[i++];
  1410.          s[i] = m;
  1411.       }
  1412.       UnLock(actdir);
  1413.       UnLock(pardir);
  1414.       FreeMem(dirinfo,sizeof(struct FileInfoBlock));
  1415.    }
  1416.  
  1417.    strcpy(strptr,s);
  1418.    Refresh1Gadget(dirgad,window);
  1419.    read_dir(s,items);
  1420.    push = slide->NextGadget;
  1421.    for(i=0;i<7;i++) {
  1422.       my_text = push->GadgetText; my_text->IText = (UBYTE *) items[i];
  1423.       if(items[i][0] == '/') {
  1424.          my_text->FrontPen = 2;
  1425.       } else {
  1426.          my_text->FrontPen = 1;
  1427.       }
  1428.       Refresh1Gadget(push,window);
  1429.       push = push->NextGadget;
  1430.    }
  1431. }
  1432.  
  1433. void CallBack_PRO(slide,window)
  1434. struct Gadget *slide;
  1435. struct Window *window;
  1436. {
  1437. ULONG class;
  1438. ULONG code;
  1439. struct IntuiMessage *my_message;
  1440. struct PropInfo *my_prop_info;
  1441. struct Gadget *push;
  1442. struct IntuiText *my_text;
  1443. char **items;
  1444. int i,n,m;
  1445. int max;
  1446.  
  1447.    m=129845; items = (char **) slide->UserData;
  1448.    max = 0; while(items[max] != NULL) max++;
  1449.    max = max - 7;
  1450.  
  1451.    my_prop_info = (struct PropInfo *) slide->SpecialInfo;
  1452.    while(1==1) {
  1453.       my_message=(struct IntuiMessage *)GetMsg(window->UserPort);
  1454.       if(my_message) {
  1455.          class = my_message->Class;      /* Save the IDCMP flag. */
  1456.          code = my_message->Code;
  1457.          ReplyMsg( my_message );
  1458.          if( class = GADGETUP ) return;
  1459.        }
  1460.  
  1461.       n = my_prop_info->VertPot; n = ((max * n) / MAXPOT);
  1462.       if((m != n) & (n < max)) {
  1463.          push = slide->NextGadget;
  1464.          for(i=0;i<7;i++) {
  1465.             my_text = push->GadgetText; my_text->FrontPen = 0;
  1466.             Refresh1Gadget(push,window);
  1467.             my_text->IText = (UBYTE *) items[n+i];
  1468.             if(items[n+i][0] == '/') {
  1469.                my_text->FrontPen = 2;
  1470.             } else {
  1471.                my_text->FrontPen = 1;
  1472.             }
  1473.             Refresh1Gadget(push,window);
  1474.             push = push->NextGadget;
  1475.          }
  1476.          m = n;
  1477.       }
  1478.    }
  1479. }
  1480.  
  1481.  
  1482. /* ------------------------------------------------------------
  1483.    now we can go and add these boxes
  1484.    ------------------------------------------------------------ */
  1485.  
  1486. void add_selector(title,window)
  1487. char *title;
  1488. struct NewWindow *window;
  1489. {
  1490. struct Gadget *gg;
  1491. char s[80],z[80];
  1492. char **items;
  1493. int m,i,l;
  1494.  
  1495.    items = (char **)tree_alloc(1200);
  1496.    for(i=0;i<300;i++) items[i] = NULL;
  1497.  
  1498. /* do string parsing for SELECTION box */
  1499.    extract_str(s,title,0,',');
  1500.    i=1; m=1;
  1501.    while(m>0) {
  1502.       m = extract_str(z,title,i,',');
  1503.       l = strlen(z);
  1504.       if(l == 0) break;
  1505.       items[i-1] = (char *) tree_alloc(l+1) ; strcpy(items[i-1],z); i++;
  1506.    }
  1507.  
  1508.    gg=create_selector(acc_x,acc_y,20,s,window,items,fn_number);
  1509. }
  1510.  
  1511. void add_fselect(title,window)
  1512. char *title;
  1513. struct NewWindow *window;
  1514. {
  1515. struct Gadget *gg;
  1516. char **items;
  1517. int i;
  1518.  
  1519.    items = (char **)tree_alloc(1200);
  1520.    for(i=0;i<300;i++) items[i] = NULL;
  1521.  
  1522.    read_dir("",items);
  1523.  
  1524.    gg=create_fselect(acc_x,acc_y,20,title,window,items,fn_number);
  1525. }
  1526.  
  1527. /* -------------------------------------------------------------
  1528.    create a file requester window
  1529.    ------------------------------------------------------------- */
  1530. void Try_Open_ASL()
  1531. {
  1532.    if(AslBase != NULL) return;
  1533.    AslBase = (struct Library *)OpenLibrary("asl.library",0);
  1534. }
  1535.  
  1536. void FileSelect(message,rtstr)
  1537. char *message,*rtstr;
  1538. {
  1539. struct FileRequester *FRptr;
  1540. struct Gadget *gg;
  1541. struct Window *win;
  1542. struct NewWindow *new_win;
  1543. struct memtree *recall;
  1544. struct Screen *WBS;
  1545. char **items;
  1546. int ml,n,i;
  1547.  
  1548.    Try_Open_ASL();
  1549.    WBS = (struct Screen *)OpenWorkBench();
  1550.    if(WBScreen == NULL) WBScreen = WBS;
  1551.    if(AslBase != NULL) {
  1552.       ScreenToFront(WBS);
  1553.       FRptr = AllocFileRequest();
  1554.       strcpy(FRptr->rf_Dir,last_dir);
  1555.       strcpy(FRptr->rf_File,last_file);
  1556.       RequestFile(FRptr);
  1557.       strcpy(last_dir,FRptr->rf_Dir);
  1558.       strcpy(last_file,FRptr->rf_File);
  1559.       strcpy(rtstr,FRptr->rf_Dir);
  1560.       if(rtstr[0] != 0) {
  1561.          if(rtstr[strlen(rtstr)-1] != ':') strcat(rtstr,"/");
  1562.       }
  1563.       strcat(rtstr,FRptr->rf_File);
  1564.       FreeFileRequest(FRptr);
  1565.       CloseLibrary(AslBase); AslBase = NULL;
  1566.       ScreenToFront(WBScreen);
  1567.       return;
  1568.    }
  1569.  
  1570.    items = (char **)malloc(1200);
  1571.    for(i=0;i<300;i++) items[i] = NULL;
  1572.  
  1573.    read_dir("",items);
  1574.  
  1575.    recall = mem_status;
  1576.  
  1577.    ml = 215 ; n = 140;
  1578.    new_win = init_window(ml,n,"FileSelect by RAKO",0,3);
  1579.    gg = create_fselect(15,15,20,message,new_win,items,150);
  1580.    win = (struct Window *) OpenWindow(new_win);
  1581.  
  1582.    var_funct[150] = FILE_SELECT; fin_flg = TRUE;
  1583.    var_value[150] = rtstr;
  1584.    MainLoop(win);
  1585.    fin_flg = FALSE;
  1586.  
  1587.    free(new_win);
  1588.    n = 0;
  1589.    while(items[n] != NULL) free(items[n++]);
  1590.    free(items);
  1591.    tree_free(recall);
  1592. }
  1593.  
  1594. /* -------------------------------------------------------------
  1595.    create a string requester window
  1596.    ------------------------------------------------------------- */
  1597. void StringBox(message,rtstr)
  1598. char *message,*rtstr;
  1599. {
  1600. struct Gadget *gg;
  1601. struct Window *win;
  1602. struct NewWindow *new_win;
  1603. struct memtree *recall;
  1604. int ml,n;
  1605.  
  1606.    recall = mem_status;
  1607.    ml = 200 ; n = 70; fn_number = 150;
  1608.    new_win = init_window(ml,n,"StringBox by RAKO",0,3);
  1609.    acc_x = 20 ; acc_y = 30 ; add_string(message,new_win);
  1610.    gg = new_win->FirstGadget;
  1611.    while((gg->GadgetType && STRGADGET) == 0) {
  1612.       gg = gg->NextGadget;
  1613.       if(gg == 0) break;
  1614.    }
  1615.    gg->Flags = GADGHCOMP|SELECTED;
  1616.    win = (struct Window *) OpenWindow(new_win);
  1617.  
  1618.    ActivateWindow(win);
  1619.    ActivateGadget(gg,win,0); /* why the hell does this not work ? */
  1620.  
  1621.    var_funct[150] = STRING; fin_flg = TRUE;
  1622.    var_value[150] = rtstr;
  1623.    MainLoop(win);
  1624.    fin_flg = FALSE;
  1625.  
  1626.    free(new_win);
  1627.    tree_free(recall);
  1628. }
  1629.  
  1630. /* -------------------------------------------------------------
  1631.     add an item to the menu list
  1632.    ------------------------------------------------------------- */
  1633. void add_item(x,y,type,text,p1,p2)
  1634. int x,y,type,p1,p2;
  1635. char text[];
  1636. {
  1637.  
  1638. /* check, if position has to be adjusted */
  1639.    if(x != -1) acc_x = x;
  1640.    if(y != -1) acc_y = y;
  1641.  
  1642.    if(fn_number > 149) {
  1643.       Help("MDL Capacity exceeded, ask a wizzard to enlarge me\n");
  1644.       printf("MDL Capacity exceeded, ask a wizzard to enlarge me\n");
  1645.       return;
  1646.    }
  1647.    var_funct[fn_number] = type;
  1648.  
  1649.    switch(type) {
  1650.  
  1651.    case PUSH:
  1652.         add_push(text,my_new_window);
  1653.         acc_y = acc_y + (3 * bas_y);
  1654.         break;
  1655.  
  1656.    case TOGGLE:
  1657.         add_toggle(text,my_new_window);
  1658.         acc_y = acc_y + (3 * bas_y);
  1659.         break;
  1660.  
  1661.    case SCALEX:
  1662.         add_xprop(text,p1,p2,my_new_window,1);
  1663.         acc_y = acc_y + (8 * bas_y);
  1664.         break;
  1665.  
  1666.    case SCALEX00:
  1667.         add_xprop(text,p1,p2,my_new_window,0);
  1668.         acc_y = acc_y + (8 * bas_y);
  1669.         break;
  1670.  
  1671.    case SCALEY:
  1672.         add_yprop(text,p1,p2,my_new_window,1);
  1673.         acc_y = acc_y + (8 * bas_y);
  1674.         break;
  1675.  
  1676.    case SCALEY00:
  1677.         add_yprop(text,p1,p2,my_new_window,0);
  1678.         acc_y = acc_y + (22 * bas_y);
  1679.         break;
  1680.  
  1681.    case SCALEY11:
  1682.         add_yprop(text,p1,p2,my_new_window,1);
  1683.         acc_y = acc_y + (22 * bas_y);
  1684.         break;
  1685.  
  1686.    case SCALEX11:
  1687.         add_xprop(text,p1,p2,my_new_window,1);
  1688.         acc_y = acc_y + (8 * bas_y);
  1689.         break;
  1690.  
  1691.    case SELECTION:
  1692.         add_selector(text,my_new_window);
  1693.         acc_y = acc_y + (75 * bas_y);
  1694.         break;
  1695.  
  1696.    case STRING:
  1697.         add_string(text,my_new_window);
  1698.         acc_y = acc_y + (5 * bas_y);
  1699.         break;
  1700.  
  1701.    case INTEGER:                                /* NEW! */
  1702.         add_integer(text,my_new_window);
  1703.         acc_y = acc_y + (5 * bas_y);
  1704.         break;
  1705.  
  1706.    case FLOAT:                                  /* NEW! */
  1707.         add_float(text,my_new_window);
  1708.         acc_y = acc_y + (5 * bas_y);
  1709.         break;
  1710.  
  1711.    case RADIO:
  1712.         return;
  1713.         break;
  1714.  
  1715.    case FILE_SELECT:
  1716.         add_fselect(text,my_new_window);
  1717.         acc_y = acc_y + (90 * bas_y);
  1718.         break;
  1719.  
  1720.    case MENU:
  1721.         add_menu(text);
  1722.         break;
  1723.  
  1724.    case NEW_MENU:
  1725.         add_new_menu(text);
  1726.         break;
  1727.  
  1728.    default:
  1729.         break;
  1730.    }
  1731. }
  1732.  
  1733. /* -------------------------------------------------------------------
  1734.  
  1735.    look for altered variables and assotiated gadgets, Update Gadgets
  1736.    (Writes back altered wariables to Gadgets)
  1737.  
  1738.    ------------------------------------------------------------------- */
  1739.  
  1740. void UpdateGadgets(window)   /* NEW! */
  1741. struct Window *window;
  1742. {
  1743. int      gadgetid;
  1744. char     *strptr;
  1745. struct   Gadget *gadget;
  1746. struct   StringInfo *my_string_info;
  1747. struct   PropInfo *my_prop_info;
  1748. USHORT   flags, horizpot, vertpot, horizbody, vertbody;
  1749. int      type,max,min,m,n;
  1750. union intfp {
  1751.          float fp;
  1752.          int   i;
  1753.       } ifp;
  1754.  
  1755.  
  1756.  
  1757.    gadget = window->FirstGadget;
  1758.    while(gadget != NULL) {
  1759.       gadget = gadget->NextGadget;
  1760.       gadgetid = gadget->GadgetID;
  1761.       if(gadget->Activation & TOGGLESELECT) {
  1762.          n = *var_value[gadgetid];
  1763.          m = 0; if(gadget->Flags & SELECTED) m = 1;
  1764.          if(n == m) continue;
  1765.          gadget->Flags |= SELECTED;
  1766.          Refresh1Gadget(gadget,window);
  1767.          if(n == 0) gadget->Flags -= SELECTED;
  1768.          continue;
  1769.       }
  1770.       if(gadget->Flags & SELECTED) continue;
  1771.       if((gadgetid < 150) && (gadgetid > 0)) {
  1772.          if(gadget->GadgetType & STRGADGET) {
  1773.             my_string_info = (struct StringInfo *) gadget->SpecialInfo;
  1774.             strptr = (char *) my_string_info->Buffer;
  1775.             if(var_funct[gadgetid] == STRING) {  /* simple string */
  1776.                strcpy(strptr,var_value[gadgetid]);
  1777.             }
  1778.             if(var_funct[gadgetid] == INTEGER) {     /* integer gadget */
  1779.                sprintf(strptr,"%d",*var_value[gadgetid]);
  1780.                my_string_info->LongInt = *var_value[gadgetid];
  1781.             }
  1782.             if(var_funct[gadgetid] == FLOAT) { /* floating point gadget */
  1783.                ifp.i = *var_value[gadgetid];
  1784.                sprintf(strptr,"%f",(double)ifp.fp);
  1785.             }
  1786.             Refresh1Gadget(gadget,window);
  1787.             continue;
  1788.          }
  1789.  
  1790.          if(gadget->GadgetType == PROPGADGET) {
  1791.             max=scale_var1[gadgetid]; min=scale_var0[gadgetid];
  1792.             n = *var_value[gadgetid];
  1793.             m = (max - min);
  1794.             if(m == 0) continue;
  1795.             n = (n - min) * MAXPOT / m;
  1796.             flags = gadget->Flags;
  1797.             my_prop_info = (struct PropInfo *) gadget->SpecialInfo;
  1798.             horizpot = my_prop_info->HorizPot;
  1799.             vertpot = my_prop_info->VertPot;
  1800.             horizbody = my_prop_info->HorizBody;
  1801.             vertbody = my_prop_info->VertBody;
  1802.             type = var_funct[gadgetid];
  1803.             if((type == SCALEY) || (type == SCALEY11) || (type == SCALEY00)) {
  1804.                vertpot = n;
  1805.             } else {
  1806.                horizpot = n;
  1807.             }
  1808. /*  !!!!!!!!!!!!!!!! Makes Trouble !!!!!!!!!!!!!!!!
  1809.             NewModifyProp(gadget,window,NULL,flags,horizpot,vertpot,horizbody,vertbody,0);
  1810.     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
  1811.          }
  1812.       }
  1813.    }
  1814. }
  1815.  
  1816. MainLoop(window)
  1817. struct Window *window;
  1818. {
  1819. BOOL close_me;
  1820. ULONG class;
  1821. ULONG code;
  1822. struct IntuiMessage *my_message;
  1823. struct Gadget *my_gadget;
  1824.  
  1825.   close_me = FALSE;
  1826.   DrawAllPropBorders(window);
  1827.   UpdateGadgets(window);
  1828.  
  1829.   while( close_me == FALSE )
  1830.   {
  1831.     Wait( 1 << window->UserPort->mp_SigBit );
  1832.  
  1833.     while(my_message=(struct IntuiMessage *)GetMsg(window->UserPort))
  1834.     {
  1835.       class = my_message->Class;      /* Save the IDCMP flag. */
  1836.       code = my_message->Code;
  1837.       ReplyMsg( my_message );
  1838.       switch( class )
  1839.       {
  1840.         case CLOSEWINDOW:  /* The user selected the Close window gadget! */
  1841.                close_me=TRUE;
  1842.                break;
  1843.              
  1844.         case GADGETDOWN:   /* The user has selected a gadget: */
  1845.                close_me=read_gadgets(my_message,window);
  1846.                break;
  1847.  
  1848.         case GADGETUP:     /* The user has released a gadget: */
  1849.               my_gadget = (struct Gadget *) my_message->IAddress;
  1850.               if(my_gadget->GadgetType == STRGADGET) {
  1851.                   close_me=read_gadgets(my_message,window);
  1852.                }
  1853.                break;
  1854.         case MENUPICK:
  1855.                CallBack_menu(code);
  1856.                break;
  1857.       }
  1858.       UpdateGadgets(window);
  1859.     }
  1860.   }
  1861.   close_gfx(window);
  1862. }
  1863.  
  1864. read_gadgets(message,window)
  1865. struct IntuiMessage *message;
  1866. struct Window *window;
  1867. {
  1868. struct Gadget *my_gadget;
  1869. int gadgetid;
  1870. int class,type;
  1871.  
  1872.    class = message->Class;      /* Save the IDCMP flag. */
  1873.    my_gadget = (struct Gadget *) message->IAddress;
  1874.    gadgetid = my_gadget->GadgetID;
  1875.    last_gadgetid = gadgetid;
  1876.  
  1877.    if(gadgetid > 200) {
  1878.       switch(gadgetid) {
  1879.       case SELBOXGAD:
  1880.          CallBack_SELBOX(my_gadget,window);
  1881.          break;
  1882.       case FSELBOXGAD:
  1883.          CallBack_FSELBOX(my_gadget,window);
  1884.          break;
  1885.       case FSELSTRING:
  1886.          CallBack_FSELSTRING(my_gadget,window);
  1887.          break;
  1888.       case SPECIALPRO:
  1889.          CallBack_PRO(my_gadget,window);
  1890.          break;
  1891.       case SPECIALOK:
  1892.          if(class == GADGETDOWN) {
  1893.             CallBack_OK(my_gadget,window);
  1894.             return(fin_flg);
  1895.          }
  1896.          break;
  1897.       case SPECIALPAR:
  1898.          if(class == GADGETDOWN) CallBack_PAR(my_gadget,window);
  1899.          break;
  1900.       case SPECIALCAN:
  1901.          if(class == GADGETDOWN) {
  1902.             CallBack_CAN(my_gadget,window);
  1903.             return(fin_flg);
  1904.          }
  1905.          break;
  1906.       }
  1907.       return(FALSE);
  1908.    }
  1909.  
  1910.    type = var_funct[gadgetid];
  1911.  
  1912.    switch(type) {
  1913.    case SCALEX:
  1914.    case SCALEY:
  1915.    case SCALEX11:
  1916.    case SCALEY11:
  1917.        prop_gadget = my_gadget;
  1918.        prop_window = window;
  1919.        CallBack_disp_prop(my_gadget,window);
  1920.        if(class == GADGETDOWN) propdwn = -1;
  1921.        if(class == GADGETUP) propdwn = 0;
  1922.        break;
  1923.    case SCALEX00:
  1924.    case SCALEY00:
  1925.        prop_gadget = my_gadget;
  1926.        prop_window = window;
  1927.        CallBack_prop(my_gadget,window);
  1928.        if(class == GADGETDOWN) propdwn = -1;
  1929.        if(class == GADGETUP) propdwn = 0;
  1930.        break;
  1931.    case TOGGLE:
  1932.        CallBack_toggle(my_gadget,window);
  1933.        break;
  1934.    case STRING:
  1935.    case INTEGER:
  1936.    case FLOAT:
  1937.        CallBack_string(my_gadget,window);
  1938.        return(fin_flg);
  1939.        break;
  1940.    case PUSH:
  1941.        if(class == GADGETDOWN) CallBack_push(my_gadget,window);
  1942.        break;
  1943.    case SELECTION:
  1944.        CallBack_string(my_gadget,window);
  1945.        break;
  1946.    case FILE_SELECT:
  1947.        CallBack_string(my_gadget,window);
  1948.        return(fin_flg);
  1949.        break;
  1950.    default:
  1951.        printf("unknown function: %d gadgetID= %d \n",type,gadgetid);
  1952.        break;
  1953.    }
  1954.    return(FALSE);
  1955. }
  1956.  
  1957. /* ********************************************************************
  1958.  
  1959.    S T R I N G H A N D L I N G
  1960.  
  1961.    ******************************************************************** */
  1962.  
  1963. /* --------------------------------------------------
  1964.    reurns in s1 s2 from nth occurence of c up to c
  1965.    -------------------------------------------------- */
  1966.  
  1967. extract_str(s1,s2,n,c)
  1968. char s1[],s2[],c;
  1969. int n;
  1970. {
  1971. int m,i,l;
  1972. char c1;
  1973.  
  1974.    m=0; l=strlen(s2);
  1975.    i = 0;
  1976.    if(n > 0) {
  1977.       for(i=0;i<l;i++) {
  1978.           c1=s2[i];
  1979.           if(c1 == c) m++;
  1980.           if(m == n) break;
  1981.       }
  1982.       s1[0] = 0;
  1983.       if(c1 != c) return(-1);
  1984.       i++;
  1985.    }
  1986.    m=0;
  1987.    while(i<l) {
  1988.       c1 = s2[i++];
  1989.       if(c1 == c) break;
  1990.       s1[m++] = c1;
  1991.    }
  1992.    s1[m] = 0;
  1993.    if(strlen(s1)==0) return(-1);
  1994.    return(1);
  1995. }
  1996.  
  1997. void dummy()
  1998. {
  1999. }
  2000.  
  2001. void set_new_pointer()
  2002. {
  2003. int n;
  2004.  
  2005.    PointerMatrix = (USHORT *) AllocMem(256,MEMF_CHIP|MEMF_PUBLIC);
  2006.  
  2007.    PointerMatrix[0]  = 0 ;
  2008.    PointerMatrix[1]  = 0 ;
  2009.    PointerMatrix[2]  = 0x8001 ;
  2010.    PointerMatrix[4]  = 0x4002 ;
  2011.    PointerMatrix[6]  = 0x2004 ;
  2012.    PointerMatrix[8]  = 0x1008 ;
  2013.    PointerMatrix[10] = 0x0810 ;
  2014.    PointerMatrix[12] = 0x0420 ;
  2015.    PointerMatrix[14] = 0x0240 ;
  2016.    PointerMatrix[16] = 0x0180 ;
  2017.    PointerMatrix[18] = 0x0240 ;
  2018.    PointerMatrix[20] = 0x0420 ;
  2019.    PointerMatrix[22] = 0x0810 ;
  2020.    PointerMatrix[24] = 0x1008 ;
  2021.    PointerMatrix[26] = 0x2004 ;
  2022.    PointerMatrix[28] = 0x4002 ;
  2023.    PointerMatrix[30] = 0x8001 ;
  2024.    for(n = 3 ; n<32 ; n = n + 2) PointerMatrix[n] = 0;
  2025.    SetPointer(my_window,PointerMatrix,(short) 15, (short) 15, (short) -8, (short) -8);
  2026. }
  2027.  
  2028. void set_old_pointer()
  2029. {
  2030.    ClearPointer(my_window);
  2031.    FreeMem(PointerMatrix,256);
  2032. }
  2033.  
  2034. RequestYesNo(text)
  2035. char *text;
  2036. {
  2037. int n;
  2038. struct IntuiText body=
  2039. { 0, 0, JAM1, 15, 5, NULL,
  2040.    ">>>>>>>>>>>>>>>!!!!!! Undefined Yes / No Requester !!!!!!!<<<<<<<<<<<<<<<<<<",
  2041.    NULL};
  2042. struct IntuiText yes=
  2043. { 0, 0, JAM1, 6, 3, NULL, "YES", NULL};
  2044. struct IntuiText no=
  2045. { 0, 0, JAM1, 6, 3, NULL, "NO", NULL};
  2046.  
  2047.    strcpy(body.IText,text);
  2048.    n = 8 * strlen(text) + 50;
  2049.   return(AutoRequest( NULL, &body, &yes, &no, NULL, NULL, n, 72));
  2050.  
  2051. }
  2052.  
  2053.  
  2054. _instr(substr,str)
  2055. char  str[],substr[];
  2056. {
  2057. int i,p,flg,l1,l2;
  2058.  
  2059.    l1=strlen(str); l2=strlen(substr);
  2060.    for(p=0; p < l1; p++) {
  2061.       flg=0;
  2062.       for(i=0; i < l2; i++) {
  2063.          if(str[p+i] != substr[i]) {
  2064.             flg = -1; break;
  2065.          }
  2066.       }
  2067.       if(flg == 0) return(p);
  2068.    }
  2069.    return(-1);
  2070. }
  2071.